/**
 * 全局工具函数
 * 包含图片路径拼接、数据处理等通用功能
 */

/**
 * 图片路径拼接
 * @param {string} url - 图片URL
 * @param {string} baseUrl - 基础URL
 * @returns {string} - 完整图片路径
 */
export function joinImgUrl(url, baseUrl = '') {
  if (!url) return '';
  
  // 如果是完整URL，直接返回
  if (url.startsWith('http://') || url.startsWith('https://') || url.startsWith('data:image')) {
    return url;
  }
  
  // 拼接基础URL和图片路径
  const base = baseUrl || process.env.VUE_APP_BASE_URL || '';
  return `${base.replace(/\/$/, '')}/${url.replace(/^\//, '')}`;
}

/**
 * 图片数组批量处理
 * @param {Array} imgArray - 图片数组（可以是字符串数组或对象数组）
 * @param {string} field - 对象数组时的图片字段名
 * @param {string} baseUrl - 基础URL
 * @returns {Array} - 处理后的图片数组
 */
export function joinImgArray(imgArray = [], field = 'url', baseUrl = '') {
  if (!Array.isArray(imgArray)) return [];
  
  return imgArray.map(item => {
    if (typeof item === 'string') {
      return joinImgUrl(item, baseUrl);
    } else if (typeof item === 'object' && item[field]) {
      return {
        ...item,
        [field]: joinImgUrl(item[field], baseUrl)
      };
    }
    return item;
  });
}

/**
 * 数据脱敏处理
 * @param {string} str - 需要脱敏的字符串
 * @param {number} startLen - 前面保留的长度
 * @param {number} endLen - 后面保留的长度
 * @param {string} mask - 掩码字符
 * @returns {string} - 脱敏后的字符串
 */
export function tuomin(str, startLen = 3, endLen = 4, mask = '*') {
  if (!str || typeof str !== 'string') return '';
  
  const len = str.length;
  if (len <= startLen + endLen) return str;
  
  const maskLen = len - startLen - endLen;
  const maskStr = mask.repeat(maskLen);
  
  return str.substring(0, startLen) + maskStr + str.substring(len - endLen);
}

/**
 * 防抖函数
 * @param {Function} func - 执行函数
 * @param {number} wait - 等待时间（毫秒）
 * @param {boolean} immediate - 是否立即执行
 * @returns {Function} - 防抖处理后的函数
 */
export function debounce(func, wait = 300, immediate = false) {
  let timeout;
  
  return function executedFunction(...args) {
    const context = this;
    
    const later = function() {
      timeout = null;
      if (!immediate) func.apply(context, args);
    };
    
    const callNow = immediate && !timeout;
    
    clearTimeout(timeout);
    timeout = setTimeout(later, wait);
    
    if (callNow) func.apply(context, args);
  };
}

/**
 * 节流函数
 * @param {Function} func - 执行函数
 * @param {number} limit - 限制时间（毫秒）
 * @returns {Function} - 节流处理后的函数
 */
export function throttle(func, limit = 300) {
  let lastCall = 0;
  
  return function executedFunction(...args) {
    const context = this;
    const now = Date.now();
    
    if (now - lastCall >= limit) {
      func.apply(context, args);
      lastCall = now;
    }
  };
}

/**
 * 深拷贝
 * @param {any} obj - 需要拷贝的对象
 * @returns {any} - 拷贝后的对象
 */
export function deepClone(obj) {
  if (obj === null || typeof obj !== 'object') return obj;
  
  // 处理日期
  if (obj instanceof Date) {
    return new Date(obj.getTime());
  }
  
  // 处理数组
  if (obj instanceof Array) {
    return obj.map(item => deepClone(item));
  }
  
  // 处理对象
  if (obj instanceof Object) {
    const clonedObj = {};
    Object.keys(obj).forEach(key => {
      clonedObj[key] = deepClone(obj[key]);
    });
    return clonedObj;
  }
  
  return obj;
}
